home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr05 / xnot12a.zip / HELP.C < prev    next >
C/C++ Source or Header  |  1993-05-20  |  8KB  |  321 lines
  1. #include "jam.h"
  2. /* Help functions for MicroGnuEmacs 2 */
  3.  
  4. #include "def.h"
  5.  
  6. #include "kbd.h"
  7. #include "key.h"
  8. #include "macro.h"
  9.  
  10. #ifndef WINDOWED
  11. # include "string.h"
  12. #endif
  13.  
  14. static int rn_(showall,(char *ind, KEYMAP *map));
  15. static VOID rn_(findbind,(PF funct, char *ind, KEYMAP *map));
  16. static VOID rn_(bindfound,(void));
  17.  
  18. /*
  19.  * Read a key from the keyboard, and look it
  20.  * up in the keymap.  Display the name of the function
  21.  * currently bound to the key.
  22.  */
  23. /*ARGSUSED*/
  24. desckey(f, n)
  25. int f, n;
  26. {
  27.     register KEYMAP *curmap;
  28.     register PF funct;
  29.     register char *pep;
  30.     char prompt[80];
  31.     int c;
  32.     int m;
  33.     int i;
  34.  
  35.     if(inmacro) 
  36.       return TRUE;        /* ignore inside keyboard macro */
  37.     (VOID) strcpy(prompt, "Describe key briefly: ");
  38.     pep = prompt + strlen(prompt);
  39.     key.k_count = 0;
  40.     m = curbp->b_nmodes;
  41.     curmap = curbp->b_modes[m]->p_map;
  42.     for(;;) {
  43.     for(;;) {
  44.         ewprintf("%s", prompt);
  45.         pep[-1] = ' ';
  46.         pep = mykeyname(pep, key.k_chars[key.k_count++] = c = getkey(FALSE));
  47.         if((funct = doscan(curmap, c)) != prefix) break;
  48.         *pep++ = '-';
  49.         *pep = '\0';
  50.         curmap = ele->k_prefmap;
  51.     }
  52.     if(funct != rescan) break;
  53.     if(ISUPPER(key.k_chars[key.k_count-1])) {
  54.         funct = doscan(curmap, TOLOWER(key.k_chars[key.k_count-1]));
  55.         if(funct == prefix) {
  56.         *pep++ = '-';
  57.         *pep = '\0';
  58.         curmap = ele->k_prefmap;
  59.         continue;
  60.         }
  61.         if(funct != rescan) break;
  62.     }
  63. nextmode:
  64.     if(--m < 0) break;
  65.     curmap = curbp->b_modes[m]->p_map;
  66.     for(i=0; i < key.k_count; i++) {
  67.         funct = doscan(curmap, key.k_chars[i]);
  68.         if(funct != prefix) {
  69.         if(i == key.k_count - 1 && funct != rescan) goto found;
  70.         funct = rescan;
  71.         goto nextmode;
  72.         }
  73.         curmap = ele->k_prefmap;
  74.     }
  75.     *pep++ = '-';
  76.     *pep = '\0';
  77.     }
  78. found:
  79.     if(funct == rescan) ewprintf("%k is not bound to any function");
  80.     else if((pep = function_name(funct)) != NULL)
  81.         ewprintf("%k runs the command '%s'", pep);
  82.     else    ewprintf("%k is bound to an unnamed function");
  83.     return TRUE;
  84. }
  85.  
  86. /*
  87.  * This function creates a table, listing all
  88.  * of the command keys and their current bindings, and stores
  89.  * the table in the *help* pop-up buffer.  This
  90.  * lets MicroGnuEMACS produce it's own wall chart.
  91.  */
  92. static BUFFER    *bp;
  93. static char buf[80];    /* used by showall and findbind */
  94.  
  95. /*ARGSUSED*/
  96. wallchart(f, n)
  97. int f, n;
  98. {
  99.     int m;
  100.     static char locbind[80] = "Local keybindings for mode ";
  101.     int showall();
  102.  
  103.     bp = bfind("*help*", TRUE);
  104.     if (bclear(bp) != TRUE) 
  105.       return FALSE;    /* Clear it out.    */
  106.     for(m=curbp->b_nmodes; m > 0; m--) 
  107.       {
  108.         (VOID) strcpy(&locbind[27], curbp->b_modes[m]->p_name);
  109.         (VOID) strcat(&locbind[27], ":");
  110.         if((addline(bp, locbind) == NULL) ||
  111.        (showall(buf, curbp->b_modes[m]->p_map) == FALSE) ||
  112.        (addline(bp, "") == NULL)) 
  113.           return FALSE;
  114.       }
  115.     if((addline(bp, "Global bindings:") == NULL) ||
  116.        (showall(buf, map_table[0].p_map) == FALSE)) 
  117.       return FALSE;
  118.  
  119.     bp->b_flag |= BFVIEW;
  120.     return popbuftop(bp);
  121. }
  122.  
  123. static    int showall(ind, map)
  124. char *ind;
  125. KEYMAP *map;
  126. {
  127.     register MAP_ELEMENT *ele;
  128.     register int i;
  129.     PF    functp;
  130.     char    *cp;
  131.     char    *cp2;
  132.     int    last;
  133.  
  134.     if(addline(bp, "") == NULL) 
  135.           return FALSE;
  136.     last = -1;
  137.     for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num] ;
  138.         ele++) 
  139.       {
  140.         if(map->map_default != rescan && ++last < ele->k_base) {
  141.         cp = mykeyname(ind, last);
  142.         if(last < ele->k_base - 1) {
  143.             (VOID) strcpy(cp, " .. ");
  144.             cp = mykeyname(cp + 4, ele->k_base - 1);
  145.         }
  146.         do { *cp++ = ' '; } 
  147.                   while(cp < &buf[16]);
  148.         (VOID) strcpy(cp, function_name(map->map_default));
  149.         if(addline(bp, buf) == NULL) 
  150.                     return FALSE;
  151.         }
  152.         last = ele->k_num;
  153.         for(i=ele->k_base; i <= last; i++) {
  154.         functp = ele->k_funcp[i - ele->k_base];
  155.         if(functp != rescan) {
  156.             if(functp != prefix) 
  157.                       cp2 = function_name(functp);
  158.             else 
  159.                       cp2 = map_name(ele->k_prefmap);
  160.             if(cp2 != NULL) {
  161.             cp = mykeyname(ind, i);
  162.             do { *cp++ = ' '; } 
  163.                           while(cp < &buf[16]);
  164.             (VOID) strcpy(cp, cp2);
  165.             if (addline(bp, buf) == NULL) 
  166.                           return FALSE;
  167.             }
  168.         }
  169.         }
  170.     }
  171.     for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num];
  172.         ele++) {
  173.         if(ele->k_prefmap != NULL) {
  174.         for(i = ele->k_base; ele->k_funcp[i - ele->k_base] != prefix; 
  175.             i++) {
  176.             if(i >= ele->k_num)  /* damaged map */
  177.             return FALSE;
  178.         }
  179.         cp = mykeyname(ind, i);
  180.         *cp++ = ' ';
  181.         if(showall(cp, ele->k_prefmap) == FALSE) 
  182.                   return FALSE;
  183.         }
  184.     }
  185.     return TRUE;
  186. }
  187.  
  188. help_help(f, n)
  189. int f, n;
  190. {
  191.     KEYMAP *kp;
  192.     PF    funct;
  193.  
  194.     if((kp = name_map("help")) == NULL) return FALSE;
  195.     ewprintf("a b c: ");
  196.     do {
  197.     funct = doscan(kp, getkey(FALSE));
  198.     } while(funct==NULL || funct==help_help);
  199.     if(macrodef && macrocount < MAXMACRO) 
  200.       macro[macrocount-1].m_funct = funct;
  201.     return (*funct)(f, n);
  202. }
  203.  
  204. static char buf2[128];
  205. static char *buf2p;
  206.  
  207. /*ARGSUSED*/
  208. apropos_command(f, n)
  209. int f, n;
  210. {
  211.     register char *cp1, *cp2;
  212.     char string[32];
  213.     FUNCTNAMES *fnp;
  214.     int i;
  215.     FUNCTNAMES fn;
  216.     BUFFER *bp;
  217.  
  218.     if (eread("apropos: ", string, sizeof(string), EFNEW) == ABORT) 
  219.       return ABORT;     /* FALSE means we got a 0 character string, 
  220.                         * which is fine 
  221.                 */
  222.     bp = bfind("*help*", TRUE);
  223.     if (bclear(bp) == FALSE) 
  224.       return FALSE;
  225.  
  226.     fnp = &fn;
  227.     for (i = 0; i < nfunct; i++)
  228.       {
  229.         if (!loadfunct(i, &fn))
  230.           {
  231.             ewprintf("Internal error! loadfunct");
  232.             return(FALSE);
  233.           }
  234.  
  235.         if (fnp->n_name[0] == '%')   /* "hidden" functions get skipped */
  236.           continue; 
  237.     for(cp1 = fnp->n_name; *cp1; cp1++) 
  238.           {
  239.         cp2 = string;
  240.         while(*cp2 && (*cp1 == *cp2))
  241.         cp1++, cp2++;
  242.         if (!*cp2) 
  243.               {
  244.         (VOID) strcpy(buf2, fnp->n_name);
  245.         buf2p = &buf2[strlen(buf2)];
  246.         findbind(fnp->n_funct, buf, map_table[0].p_map);
  247.         if(addline(bp, buf2) == NULL) 
  248.                   return FALSE;
  249.         break;
  250.          } 
  251.            else 
  252.              cp1 -= cp2 - string;
  253.       }
  254.       }
  255.     bp->b_flag |= BFVIEW;
  256.     return popbuftop(bp);
  257. }
  258.  
  259. static VOID findbind(funct, ind, map)
  260. PF funct;
  261. char *ind;
  262. KEYMAP *map;
  263. {
  264.     register MAP_ELEMENT *ele;
  265.     register int i;
  266.     char    *cp;
  267.     int        last;
  268.  
  269.     last = -1;
  270.     for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; 
  271.       ele++) {
  272.         if(map->map_default == funct && ++last < ele->k_base) {
  273.           cp = mykeyname(ind, last);
  274.           if(last < ele->k_base - 1) {
  275.             (VOID) strcpy(cp, " .. ");
  276.             (VOID) mykeyname(cp + 4, ele->k_base - 1);
  277.           }
  278.         bindfound();
  279.       }
  280.     last = ele->k_num;
  281.     for(i=ele->k_base; i <= last; i++) {
  282.       if(funct == ele->k_funcp[i - ele->k_base]) {
  283.         if(funct == prefix) {
  284.           cp = map_name(ele->k_prefmap);
  285.           if (!cp || !*cp)
  286.               continue;      /* !!!!! some kind of internal error  (JAM) */
  287.           if(strncmp(cp, buf2, strlen(cp)) != 0) 
  288.             continue;
  289.           }
  290.         (VOID) mykeyname(ind, i);
  291.         bindfound();
  292.         }
  293.       }
  294.     }
  295.     for(ele = &map->map_element[0]; ele < &map->map_element[map->map_num]; 
  296.       ele++) {
  297.     if(ele->k_prefmap != NULL) {
  298.         for(i = ele->k_base; ele->k_funcp[i - ele->k_base] != prefix; i++) 
  299.               {
  300.                 if(i >= ele->k_num) 
  301.                   return; /* damaged */
  302.               }
  303.         cp = mykeyname(ind, i);
  304.         *cp++ = ' ';
  305.         findbind(funct, cp, ele->k_prefmap);
  306.     }
  307.     }
  308. }
  309.  
  310. static VOID bindfound() 
  311. {
  312.     if(buf2p < &buf2[32]) {
  313.     do { *buf2p++ = ' '; } while(buf2p < &buf2[32]);
  314.     } else {
  315.     *buf2p++ = ',';
  316.     *buf2p++ = ' ';
  317.     }
  318.     (VOID) strcpy(buf2p, buf);
  319.     buf2p += strlen(buf);
  320. }
  321.